import plugin from '../../../lib/plugins/plugin.js'
import { createRequire } from 'module'
import { segment } from 'oicq'
import { exec } from 'child_process'
import { promisify } from 'util'
import path from 'path'
import { fileURLToPath } from 'url'
import SignService from '../model/SignService.js'
import UserManager from '../model/UserManager.js'
import Storage from '../model/Storage.js'
import Config from '../model/Config.js'

const execAsync = promisify(exec)

const require = createRequire(import.meta.url)
const { name, version } = require('../package.json')

const signService = new SignService()
const userManager = new UserManager()

// 全局定时任务列表（用于动态更新）
let globalTasks = []

/**
 * 米游社签到插件
 */
export class SignIn extends plugin {
  constructor() {
    // 执行数据清理（修复异常UID数据）
    setTimeout(() => {
      try {
        const cleanResult = Storage.cleanAllUsersUid()
        if (cleanResult.cleaned > 0 || cleanResult.migrated > 0) {
          logger.mark('[签到插件] 📝 数据清理完成')
          logger.mark(`[签到插件] ✨ 清理无效键: ${cleanResult.cleaned}个用户`)
          logger.mark(`[签到插件] 🔄 迁移旧格式: ${cleanResult.migrated}个用户`)
        }
      } catch (error) {
        logger.error('[签到插件] 数据清理失败:', error)
      }
    }, 2000)
    
    // 初始化定时任务
    globalTasks = SignIn.loadTasks()
    
    super({
      name: '米游社签到',
      dsc: '米游社原神/星铁签到功能',
      event: 'message',
      priority: 500,
      rule: [
        {
          reg: '^#(原神)?签到$',
          fnc: 'sign'
        },
        {
          reg: /^(\*|#星铁|#sr)签到$/,
          fnc: 'signSR'
        },
        {
          reg: '^#全部签到$',
          fnc: 'signAll'
        },
        {
          reg: '^#签到帮助$',
          fnc: 'signHelp'
        },
        {
          reg: '^#(开启|关闭)自动签到$',
          fnc: 'autoSign'
        },
        {
          reg: /^#(开启|关闭)(原神|星铁)自动签到$/,
          fnc: 'autoSignGame'
        },
        {
          reg: /^(\*|#sr)(开启|关闭)自动签到$/,
          fnc: 'autoSignSR'
        },
        {
          reg: '^#(开启|关闭)私聊推送$',
          fnc: 'privatePush'
        },
        {
          reg: '^#(开启|关闭)失败推送$',
          fnc: 'failPush'
        },
        {
          reg: '^#签到状态$',
          fnc: 'signStatus'
        },
        {
          reg: /^(\*|#星铁|#sr)签到状态$/,
          fnc: 'signStatusSR'
        },
        {
          reg: '^#删除(ck|cookie|CK|Cookie)$',
          fnc: 'deleteCookie'
        },
        {
          reg: '^#同步(ck|cookie|CK|Cookie)$',
          fnc: 'syncCookie'
        },
        {
          reg: '^#(更新|升级)签到插件$',
          fnc: 'updatePlugin',
          permission: 'master'
        },
        {
          reg: '^#签到插件版本$',
          fnc: 'pluginVersion'
        }
      ]
    })

    // 使用全局任务列表
    this.task = globalTasks
    
    logger.info(`[${name}] 签到插件 v${version} 初始化完成`)
    if (Config.get('autoSign.enable', true)) {
      const gsCron = Config.get('autoSign.gsCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
      const srCron = Config.get('autoSign.srCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
      logger.info(`[米游社签到] 注册定时任务: 原神自动签到 [${gsCron}]`)
      logger.info(`[米游社签到] 注册定时任务: 星铁自动签到 [${srCron}]`)
    }
  }

  /**
   * 加载定时任务配置（静态方法）
   */
  static loadTasks() {
    const gsCron = Config.get('autoSign.gsCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
    const srCron = Config.get('autoSign.srCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
    
    return [
      {
        cron: gsCron,
        name: '原神自动签到',
        fnc: () => SignIn.autoSignTaskGSStatic(),
        log: true
      },
      {
        cron: srCron,
        name: '星铁自动签到',
        fnc: () => SignIn.autoSignTaskSRStatic(),
      log: true
      }
    ]
  }

  /**
   * 重新加载定时任务（热更新）
   */
  static reloadTasks() {
    try {
      const gsCron = Config.get('autoSign.gsCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
      const srCron = Config.get('autoSign.srCron') || Config.get('autoSign.cron', '0 0 8 * * ?')
      
      // 更新全局任务列表
      globalTasks[0].cron = gsCron
      globalTasks[1].cron = srCron
      
      logger.mark('[米游社签到] 📝 定时任务已更新')
      logger.mark(`[米游社签到] ⏰ 原神自动签到: ${gsCron}`)
      logger.mark(`[米游社签到] ⏰ 星铁自动签到: ${srCron}`)
      logger.mark('[米游社签到] ✅ 配置已生效，无需重启')
      
      return true
    } catch (error) {
      logger.error('[米游社签到] 重新加载定时任务失败:', error)
      return false
    }
  }

  /**
   * 静态方法：原神自动签到任务
   */
  static async autoSignTaskGSStatic() {
    if (!Config.get('autoSign.enable', true)) {
      return
    }

    logger.info('[签到插件] 开始执行原神自动签到')
    const result = await signService.autoSignTaskByGame('gs')
    logger.info(`[签到插件] 原神签到完成: 成功${result.success}个, 失败${result.failed}个`)

    // 推送结果
    const pushEnabled = Config.get('autoSign.push', true)
    if (pushEnabled && result.total > 0) {
      await SignIn.pushSignResultStatic(result)
    }
  }

  /**
   * 静态方法：星铁自动签到任务
   */
  static async autoSignTaskSRStatic() {
    if (!Config.get('autoSign.enable', true)) {
      return
    }

    logger.info('[签到插件] 开始执行星铁自动签到')
    const result = await signService.autoSignTaskByGame('sr')
    logger.info(`[签到插件] 星铁签到完成: 成功${result.success}个, 失败${result.failed}个`)

    // 推送结果
    const pushEnabled = Config.get('autoSign.push', true)
    if (pushEnabled && result.total > 0) {
      await SignIn.pushSignResultStatic(result)
    }
  }

  /**
   * 静态方法：推送签到结果
   */
  static async pushSignResultStatic(result) {
    try {
      const pushEnabled = Config.get('autoSign.push', true)
      
      if (!pushEnabled) {
        logger.info('[签到插件] 推送功能未开启')
        return
      }
      
      // 获取Bot实例
      let BotInstance = null
      if (typeof Bot !== 'undefined') {
        BotInstance = Bot
      } else if (global.Bot) {
        BotInstance = global.Bot
      } else if (Bot?.adapter) {
        BotInstance = Bot
      }
      
      if (BotInstance) {
        await signService.pushSignResult(result, BotInstance)
        logger.info('[签到插件] 签到结果推送完成')
      } else {
        logger.error('[签到插件] 无法获取Bot实例，推送失败')
      }
    } catch (error) {
      logger.error('[签到插件] 推送失败:', error.message)
    }
  }

  /**
   * 验证 Cookie 是否包含所有必需字段
   * @param {String} cookie - Cookie 字符串
   * @returns {Object} { valid: Boolean, missing: Array }
   */
  validateCookieFields(cookie) {
    const cookieObj = userManager.parseCookie(cookie)
    
    const hasLtoken = !!cookieObj.ltoken
    const hasLtuid = !!cookieObj.ltuid
    const hasCookieToken = !!(cookieObj.cookie_token || cookieObj.cookie_token_v2)
    const hasAccountId = !!(cookieObj.account_id || cookieObj.account_id_v2)
    
    const missing = []
    if (!hasLtoken) missing.push('ltoken')
    if (!hasLtuid) missing.push('ltuid')
    if (!hasCookieToken) missing.push('cookie_token')
    if (!hasAccountId) missing.push('account_id')
    
    return {
      valid: missing.length === 0,
      missing
    }
  }

  /**
   * 自动同步 Cookie（当失效时）
   * @param {Object} e - 消息事件对象
   * @param {Number} qq - 用户QQ
   * @param {Object} result - 签到结果
   * @param {String} uid - 游戏UID
   * @param {String} game - 游戏类型（gs/sr）
   * @param {String} gameName - 游戏名称
   * @returns {Boolean} 是否处理成功
   */
  async handleCookieExpired(e, qq, result, uid, game, gameName) {
    // 检查是否是 Cookie 失效
    if (!result.success && (result.retcode === -10001 || result.retcode === -100)) {
      logger.info(`[签到插件] Cookie失效，尝试自动同步: QQ=${qq}`)
      
      // 尝试重新从 Yunzai 同步
      const yunzaiCookie = await userManager.getYunzaiCookie(e)
      if (yunzaiCookie) {
        const validation = this.validateCookieFields(yunzaiCookie.cookie)
        
        if (validation.valid) {
          // 保存到本地
          userManager.storage.saveUserCookie(qq, yunzaiCookie.cookie, yunzaiCookie.uid)
          logger.info(`[签到插件] 自动同步成功，重新签到: QQ=${qq}`)
          
          // 使用新 Cookie 重试签到
          const retryResult = await signService.sign(qq, uid, yunzaiCookie.cookie, game)
          let msg = signService.formatSignResult(retryResult, gameName)
          msg += '\n\n🔄 已自动更新 Cookie'
          await this.reply(msg, true)
          return true
        }
      }
      
      // 如果自动同步失败，提示用户手动同步
      await this.reply([
        result.message,
        '',
        '📌 Cookie 已失效，请尝试：',
        '• 发送 #同步cookie 从云崽主体同步',
        '• 发送 #扫码登录 重新绑定'
      ].join('\n'))
      return true
    }
    
    return false
  }

  /**
   * 显示 Cookie 不可用提示
   */
  async showCookieUnavailableMsg() {
    await this.reply([
      '❌ Cookie 不可用',
      '',
      '📌 快速解决方案：',
      '• 发送 #同步cookie 从云崽主体同步',
      '• 发送 #扫码登录 快速绑定',
      '',
      '💡 获取帮助：#签到帮助'
      ].join('\n'))
  }

  /**
   * 添加 Cookie 来源提示
   * @param {String} msg - 原始消息
   * @param {Object} cookieData - Cookie 数据对象
   * @returns {String} 添加来源提示后的消息
   */
  addCookieSourceHint(msg, cookieData) {
    if (cookieData.source === 'yunzai' || cookieData.source === 'runtime') {
      return msg + '\n\n💡 使用云崽主体 Cookie'
    } else if (cookieData.source === 'local') {
      return msg + '\n\n💡 使用本地绑定 Cookie'
    }
    return msg
  }

  /**
   * 签到功能
   */
  async sign(e) {
    const qq = e.user_id
    
    // 检测旧版数据格式
    if (userManager.storage.isOldDataFormat(qq)) {
      await this.reply([
        '❌ 检测到旧版数据格式',
        '',
        '📌 请重新同步Cookie以使用新版功能：',
        '• 发送 #同步cookie - 从云崽主体同步',
        '• 发送 #扫码登录 - 重新绑定',
        '',
        '💡 新版支持分别记录原神和星铁的签到数据'
      ].join('\n'), true)
      return true
    }
    
    const cookieData = await userManager.getCookie(qq, e)
    
    if (!cookieData) {
      await this.showCookieUnavailableMsg()
      return true
    }

    // 获取原神UID（从本地或API）
    let gsUid = await userManager.getGameUid(qq, 'gs', e)
    if (!gsUid) {
      gsUid = await userManager.getGameUidFromApi(qq, cookieData.cookie, 'gs')
    }
    
    if (!gsUid) {
      await this.reply([
        '❌ 未找到原神UID',
        '',
        '📌 请尝试：',
        '• 发送 #同步cookie - 从云崽主体同步',
        '• 发送 #扫码登录 - 重新绑定'
      ].join('\n'), true)
      return true
    }

    const result = await signService.sign(qq, gsUid, cookieData.cookie, 'gs')
    
    // 处理 Cookie 失效的情况
    const handled = await this.handleCookieExpired(e, qq, result, gsUid, 'gs', '原神')
    if (handled) return true
    
    // 格式化并发送签到结果
    let msg = signService.formatSignResult(result, '原神')
    msg = this.addCookieSourceHint(msg, cookieData)
    await this.reply(msg, true)
    
    return true
  }

  /**
   * 星铁签到
   */
  async signSR(e) {
    const qq = e.user_id
    
    // 检测旧版数据格式
    if (userManager.storage.isOldDataFormat(qq)) {
      await this.reply([
        '❌ 检测到旧版数据格式',
        '',
        '📌 请重新同步Cookie以使用新版功能：',
        '• 发送 #同步cookie - 从云崽主体同步',
        '• 发送 #扫码登录 - 重新绑定',
        '',
        '💡 新版支持分别记录原神和星铁的签到数据'
      ].join('\n'), true)
      return true
    }
    
    const cookieData = await userManager.getCookie(qq, e)
    
    if (!cookieData) {
      await this.showCookieUnavailableMsg()
      return true
    }

    // 获取星铁UID（本地或API）
    let srUid = await userManager.getGameUid(qq, 'sr', e)
    if (!srUid) {
      srUid = await userManager.getGameUidFromApi(qq, cookieData.cookie, 'sr')
    }
    
    if (!srUid) {
      await this.reply([
        '❌ 未找到星铁UID',
        '',
        '可能原因：',
        '1. 该账号未创建星铁角色',
        '2. Cookie未授权星铁游戏数据',
        '',
        '解决方法：',
        '• 在游戏内创建星铁角色',
        '• 确保Cookie包含星铁游戏权限',
        '• 或使用 #全部签到 自动识别可用游戏'
      ].join('\n'))
      return true
    }

    const result = await signService.sign(qq, srUid, cookieData.cookie, 'sr')
    
    // 处理 Cookie 失效的情况
    const handled = await this.handleCookieExpired(e, qq, result, srUid, 'sr', '星铁')
    if (handled) return true
    
    // 格式化并发送签到结果
    let msg = signService.formatSignResult(result, '星铁')
    msg = this.addCookieSourceHint(msg, cookieData)
    await this.reply(msg, true)
    
    return true
  }

  /**
   * 全部签到功能（原神+星铁）
   */
  async signAll(e) {
    const qq = e.user_id
    
    // 优先从 Yunzai 获取，其次从本地获取
    const cookieData = await userManager.getCookie(qq, e)
    
    if (!cookieData) {
      await this.reply([
        '❌ 未找到Cookie',
        '',
        '📖 获取帮助：',
        '• #签到帮助 - 查看完整使用教程',
        '',
        '💡 推荐使用 #扫码登录 一键绑定'
      ].join('\n'))
      return true
    }

    const results = []
    let signCount = 0

    // 原神签到
    let gsUid = await userManager.getGameUid(qq, 'gs', e)
    if (!gsUid) {
      gsUid = await userManager.getGameUidFromApi(qq, cookieData.cookie, 'gs')
    }
    if (gsUid) {
      const gsResult = await signService.sign(qq, gsUid, cookieData.cookie, 'gs')
    results.push(signService.formatSignResult(gsResult, '原神'))
      signCount++
    }

    // 星铁签到
    let srUid = await userManager.getGameUid(qq, 'sr', e)
    if (!srUid) {
      srUid = await userManager.getGameUidFromApi(qq, cookieData.cookie, 'sr')
    }
    if (srUid) {
      const srResult = await signService.sign(qq, srUid, cookieData.cookie, 'sr')
    results.push(signService.formatSignResult(srResult, '星铁'))
      signCount++
    }

    if (signCount === 0) {
      await this.reply([
        '❌ 未找到任何游戏账号',
        '',
        '可能原因：',
        '• 该账号未创建原神或星铁角色',
        '• Cookie未授权游戏数据',
        '',
        '请在游戏内创建角色后重试'
      ].join('\n'))
      return true
    }

    // 添加来源提示
    const sourceText = cookieData.source === 'local' 
      ? '💡 使用本地绑定 Cookie' 
      : '💡 使用 Yunzai 主体 Cookie'
    results.push(sourceText)

    await this.reply(results.join('\n\n'), true)
    return true
  }

  /**
   * 签到帮助
   */
  async signHelp(e) {
    const helpMsg = [
      '【米游社签到插件 帮助】',
      '',
      '✨ 智能Cookie管理',
      '自动同步 Yunzai 主体完整Cookie',
      '优先使用主体，降级使用本地备份',
      '',
      '📱 签到功能：',
      '#签到 - 原神签到',
      '*签到 或 #星铁签到 或 #sr签到 - 星铁签到',
      '#全部签到 - 原神+星铁一起签到',
      '#签到状态 - 查看原神签到状态',
      '*签到状态 或 #星铁签到状态 - 查看星铁签到状态',
      '',
      '🍪 Cookie管理：',
      '#扫码登录 - 扫码绑定所有游戏（推荐）',
      '#我的ck - 查看绑定信息',
      '#同步cookie - 从云崽主体同步到本地',
      '#删除cookie - 删除本地备份',
      '',
      '⏰ 自动签到：',
      '#开启自动签到 - 开启全部游戏自动签到',
      '#关闭自动签到 - 关闭全部游戏自动签到',
      '#开启原神自动签到 - 仅开启原神自动签到',
      '#开启星铁自动签到 - 仅开启星铁自动签到',
      '*开启自动签到 或 #sr开启自动签到 - 星铁自动签到（简写）',
      '',
      '📢 签到推送：',
      '#开启私聊推送 - 接收每日签到成功和失败消息',
      '#关闭私聊推送 - 关闭私聊推送',
      '#开启失败推送 - 仅接收签到失败消息',
      '#关闭失败推送 - 关闭失败推送',
      '💡 群聊推送会自动发送到最后一次开启自动签到的群',
      '',
      '💡 推荐使用方式：',
      '• 私聊机器人发送 #扫码登录（最简单）',
      '• 签到命令会自动同步，或手动 #同步cookie',
      '',
      '⚠️ 重要提示：',
      '• 推荐使用 #扫码登录 一键绑定所有游戏',
      '• 支持原神、星铁两个游戏自动签到',
      '• 绑定后发送 #签到 即可使用',
      '',
      `📦 插件版本：v${version}`
    ].join('\n')

    await this.reply(helpMsg)
    return true
  }

  /**
   * 自动签到开关（全部游戏）
   */
  async autoSign(e) {
    await this.setAutoSign(e, 'all')
    return true
  }

  /**
   * 指定游戏自动签到开关
   */
  async autoSignGame(e) {
    const match = e.msg.match(/^#(开启|关闭)(原神|星铁)自动签到$/)
    const gameName = match[2]
    const game = gameName === '原神' ? 'gs' : 'sr'
    await this.setAutoSign(e, game)
    return true
  }

  /**
   * 星铁自动签到开关（简写命令）
   */
  async autoSignSR(e) {
    await this.setAutoSign(e, 'sr')
    return true
  }

  /**
   * 设置自动签到（通用方法）
   */
  async setAutoSign(e, game = 'all') {
    const qq = e.user_id
    const action = /开启/.test(e.msg)

    // 检查是否有 Cookie（Yunzai 或本地）
    const cookieData = await userManager.getCookie(qq, e)
    
    if (!cookieData) {
      await this.reply([
        '❌ 未找到Cookie',
        '',
        '📖 获取帮助：',
        '• #签到帮助 - 查看完整使用教程',
        '',
        '💡 推荐使用 #扫码登录 一键绑定'
      ].join('\n'))
      return
    }

    // 如果是开启自动签到
    if (action) {
      // 1. 保存 Cookie 到本地（不传 UID，避免覆盖）
      if (cookieData.source !== 'local') {
        // 获取现有用户数据，保留现有 UID
        const user = userManager.storage.getUser(qq) || {}
        const existingUid = user.uid || {}
        
        // 保存 Cookie，同时保留现有 UID
        userManager.storage.saveUserCookie(qq, cookieData.cookie, existingUid)
        logger.info(`[签到插件] 已自动保存 Yunzai Cookie 到本地，用于自动签到`)
      }
      
      // 2. 根据游戏类型获取并保存 UID
      const gamesToEnable = game === 'all' ? ['gs', 'sr'] : [game]
      
      for (const gameType of gamesToEnable) {
        // 检查是否已有该游戏的 UID
        let gameUid = await userManager.getGameUid(qq, gameType, e)
        
        // 如果没有，尝试从 API 获取
        if (!gameUid) {
          gameUid = await userManager.getGameUidFromApi(qq, cookieData.cookie, gameType)
          if (gameUid) {
            logger.info(`[签到插件] 开启${gameType === 'gs' ? '原神' : '星铁'}自动签到，已获取并保存 UID: ${gameUid}`)
          } else {
            logger.warn(`[签到插件] 无法获取${gameType === 'gs' ? '原神' : '星铁'}UID，该游戏可能未创建角色`)
          }
        }
      }
      
      // 3. 如果是在群聊中开启自动签到，保存群聊ID用于推送
      if (e.isGroup) {
        userManager.setAutoSignGroup(qq, e.group_id)
        logger.info(`[签到插件] 保存群聊ID ${e.group_id} 用于推送签到结果`)
      }
    }

    const result = userManager.setAutoSign(qq, game, action)
    
    if (result.success) {
      // 获取签到时间配置
      const gsCron = Config.get('autoSign.gsCron', '0 0 8 * * ?')
      const srCron = Config.get('autoSign.srCron', '0 0 8 * * ?')
      const gsTimeDesc = this.parseCron(gsCron)
      const srTimeDesc = this.parseCron(srCron)
      
      const gameNames = { gs: '原神', sr: '星铁', all: '全部游戏' }
      const gameName = gameNames[game] || game
      
      // 获取当前自动签到状态
      const autoSignStatus = userManager.storage.getUserAutoSign(qq)
      const statusText = game === 'all' 
        ? `原神: ${autoSignStatus.gs ? '✓' : '✗'}, 星铁: ${autoSignStatus.sr ? '✓' : '✗'}`
        : `${gameName}: ${autoSignStatus[game] ? '✓' : '✗'}`
      
      // 根据游戏类型显示签到时间
      let timeInfo = ''
      if (action) {
        if (game === 'all') {
          // 全部游戏，显示两个时间
          if (gsCron === srCron) {
            timeInfo = `签到时间：${gsTimeDesc}`
          } else {
            timeInfo = `签到时间：\n  • 原神 ${gsTimeDesc}\n  • 星铁 ${srTimeDesc}`
          }
        } else if (game === 'gs') {
          timeInfo = `签到时间：${gsTimeDesc}`
        } else if (game === 'sr') {
          timeInfo = `签到时间：${srTimeDesc}`
        }
      }
      
      const messages = [
        `${action ? '✓ 已开启' : '✗ 已关闭'} ${gameName}自动签到`,
        '',
        `当前状态：${statusText}`,
        timeInfo,
        action && cookieData.source !== 'local' ? '💾 已自动保存Cookie到本地用于自动签到' : ''
      ]

      // 检查推送配置
      const pushEnabled = Config.get('autoSign.push', true)
      
      if (action && e.isGroup) {
        if (pushEnabled) {
          messages.push('📢 签到结果将推送到本群')
          messages.push('💬 可发送 #开启私聊推送 接收个人签到详情')
        } else {
          messages.push('')
          messages.push('⚠️ 推送功能已在配置中关闭')
          messages.push('签到结果将不会推送到群聊')
          messages.push('')
          messages.push('💡 如需开启推送：')
          messages.push('1. 通过锅巴插件配置，勾选"是否推送签到结果"')
          messages.push('2. 或编辑 config/config.yaml，设置 autoSign.push: true')
        }
      }

      if (action) {
        messages.push('')
        messages.push('⚙️ 修改签到时间请使用锅巴插件配置（支持可视化编辑）')
      }
      
      await this.reply(messages.filter(Boolean).join('\n'))
    } else {
      await this.reply(result.message)
    }
  }

  /**
   * 开启/关闭私聊推送
   */
  async privatePush(e) {
    const qq = e.user_id
    const action = /开启/.test(e.msg)

    // 检查全局推送配置
    const pushEnabled = Config.get('autoSign.push', true)
    
    if (action && !pushEnabled) {
      await this.reply([
        '⚠️ 推送功能已在配置中关闭',
        '',
        '即使开启私聊推送，也无法接收签到结果',
        '',
        '💡 如需使用推送功能，请先开启全局推送：',
        '1. 通过锅巴插件配置，勾选"是否推送签到结果"',
        '2. 或编辑 config/config.yaml，设置 autoSign.push: true',
        '',
        '⚙️ 开启后请重启 Yunzai 使配置生效'
      ].join('\n'), true)
      return true
    }

    const result = userManager.setPushConfig(qq, {
      privateSuccess: action,
      privateFail: action
    })

    if (result.success) {
      await this.reply([
        `${action ? '✓ 已开启' : '✗ 已关闭'}私聊推送`,
        '',
        action ? '将接收每日签到的成功和失败消息' : '不再接收签到推送',
        action ? '如只想接收失败消息，请发送 #关闭私聊推送 后再发送 #开启失败推送' : ''
      ].filter(Boolean).join('\n'), true)
    } else {
      await this.reply(result.message, true)
    }
    
    return true
  }

  /**
   * 开启/关闭失败推送
   */
  async failPush(e) {
    const qq = e.user_id
    const action = /开启/.test(e.msg)

    // 检查全局推送配置
    const pushEnabled = Config.get('autoSign.push', true)
    
    if (action && !pushEnabled) {
      await this.reply([
        '⚠️ 推送功能已在配置中关闭',
        '',
        '即使开启失败推送，也无法接收签到结果',
        '',
        '💡 如需使用推送功能，请先开启全局推送：',
        '1. 通过锅巴插件配置，勾选"是否推送签到结果"',
        '2. 或编辑 config/config.yaml，设置 autoSign.push: true',
        '',
        '⚙️ 开启后请重启 Yunzai 使配置生效'
      ].join('\n'), true)
      return true
    }

    const result = userManager.setPushConfig(qq, {
      privateFail: action
    })

    if (result.success) {
      await this.reply([
        `${action ? '✓ 已开启' : '✗ 已关闭'}失败推送`,
        '',
        action ? '仅在签到失败时推送私聊消息' : '不再接收失败推送'
      ].join('\n'), true)
    } else {
      await this.reply(result.message, true)
    }

    return true
  }

  /**
   * 原神签到状态查询
   */
  async signStatus(e) {
    await this.querySignStatus(e, 'gs', '原神')
    return true
  }

  /**
   * 星铁签到状态查询
   */
  async signStatusSR(e) {
    await this.querySignStatus(e, 'sr', '星铁')
    return true
  }

  /**
   * 签到状态查询（通用方法）
   */
  async querySignStatus(e, game = 'gs', gameName = '原神') {
    const qq = e.user_id
    const cookieData = await userManager.getCookie(qq, e)
    
    if (!cookieData) {
      await this.reply([
        '❌ 未找到Cookie',
        '',
        '📖 获取帮助：',
        '• #签到帮助 - 查看完整使用教程',
        '',
        '💡 推荐使用 #扫码登录 一键绑定'
      ].join('\n'))
      return
    }

    // 获取UID（从本地或API）
    let uid = await userManager.getGameUid(qq, game, e)
    if (!uid) {
      uid = await userManager.getGameUidFromApi(qq, cookieData.cookie, game)
    }

    if (!uid) {
      await this.reply(`❌ 未找到${gameName}UID\n请确保已创建${gameName}角色`)
      return
    }

    const status = await signService.getSignStatus(qq, uid, cookieData.cookie, game)
    
    if (!status.success) {
      await this.reply(`查询失败：${status.message}`)
      return
    }

    const stats = userManager.getUserStats(qq)
    const localUserInfo = userManager.getUserInfo(qq)
    
    const autoSignStatus = localUserInfo?.autoSign || { gs: false, sr: false }
    const currentAutoSign = game === 'gs' ? autoSignStatus.gs : autoSignStatus.sr
    
    const msgLines = [
      `【${gameName}签到状态】`,
      `UID：${uid}`,
      `今日签到：${status.data.isSigned ? '已签到 ✓' : '未签到 ✗'}`
    ]
    
    // 显示今日奖励
    if (status.data.reward) {
      msgLines.push(`今日奖励：${status.data.reward.name} x${status.data.reward.count}`)
    }
    
    msgLines.push(
      `本月签到：${status.data.totalSignDay}天`,
      `本月漏签：${status.data.missedDays || 0}次`,
      '',
      '【历史统计】',
      `总签到次数：${stats.total}次`,
      `成功次数：${stats.success}次`,
      `${gameName}自动签到：${currentAutoSign ? '已开启 ✓' : '已关闭 ✗'}`,
      '',
      `💡 Cookie来源：${cookieData.source === 'local' ? '本地绑定' : 'Yunzai主体'}`
    )

    await this.reply(msgLines.join('\n'), true)
  }

  /**
   * 删除Cookie
   */
  async deleteCookie(e) {
    const qq = e.user_id
    
    const result = userManager.deleteCookie(qq)
    await this.reply(result.message, true)
    
    return true
  }

  /**
   * 同步Yunzai主体Cookie到本地
   */
  async syncCookie(e) {
    const qq = e.user_id
    
    await this.reply('⏳ 正在从 Yunzai 主体同步 Cookie...', true)
    
    try {
      // 尝试获取 Yunzai Cookie
      const yunzaiCookie = await userManager.getYunzaiCookie(e)
      
      if (!yunzaiCookie) {
        await this.reply([
          '❌ 同步失败：未找到 Cookie',
          '',
          '📌 请先绑定 Cookie',
          '   命令：#扫码登录（推荐）',
          '',
          '💡 绑定后发送 #同步cookie 同步到本地'
        ].join('\n'), true)
      return true
    }

      // 验证 Cookie 完整性
      const validation = this.validateCookieFields(yunzaiCookie.cookie)
      
      if (!validation.valid) {
        await this.reply([
          '❌ 同步失败：Cookie 不完整',
          '',
          `缺少字段：${validation.missing.join('、')}`,
          '',
          '📌 解决方案：',
          '1. 重新获取完整 Cookie 并绑定',
          '2. 或使用扫码登录获取完整 Cookie',
          '',
          '💡 Cookie 获取帮助：#签到帮助'
        ].join('\n'), true)
      return true
    }

      // 保存到本地
      userManager.storage.saveUserCookie(qq, yunzaiCookie.cookie, yunzaiCookie.uid)
      
      // 获取星铁UID
      let srUid = null
      try {
        srUid = await userManager.getGameUid(qq, 'sr', e)
        if (!srUid) {
          srUid = await userManager.getGameUidFromApi(qq, yunzaiCookie.cookie, 'sr')
        }
      } catch (error) {
        logger.warn('[签到插件] 获取星铁UID失败:', error.message)
      }
      
      // 验证 Cookie 是否可用（尝试查询签到状态）
      const msgLines = ['✅ Cookie 同步成功！', '']
      
      // 显示UID信息
      msgLines.push(`🎮 原神UID：${yunzaiCookie.uid}`)
      if (srUid) {
        msgLines.push(`🎮 星铁UID：${srUid}`)
      } else {
        msgLines.push(`🎮 星铁UID：未找到（未创建角色或Cookie无权限）`)
      }
      msgLines.push(`📦 来源：Yunzai 主体`, '')
      
      // 查询签到状态
      try {
        // 查询原神签到状态
        const gsStatus = await signService.getSignStatus(qq, yunzaiCookie.uid, yunzaiCookie.cookie, 'gs')
        if (gsStatus.success) {
          const signed = gsStatus.data.isSigned ? '已签' : '未签'
          const rewardText = gsStatus.data.reward ? ` | ${gsStatus.data.reward.name}` : ''
          msgLines.push(`📊 原神签到：${signed}（${gsStatus.data.totalSignDay}天）${rewardText}`)
        }
        
        // 查询星铁签到状态（如果有星铁UID）
        if (srUid) {
          const srStatus = await signService.getSignStatus(qq, srUid, yunzaiCookie.cookie, 'sr')
          if (srStatus.success) {
            const signed = srStatus.data.isSigned ? '已签' : '未签'
            const rewardText = srStatus.data.reward ? ` | ${srStatus.data.reward.name}` : ''
            msgLines.push(`📊 星铁签到：${signed}（${srStatus.data.totalSignDay}天）${rewardText}`)
          }
        }
      } catch (error) {
        logger.warn('[签到插件] 查询签到状态失败:', error.message)
      }
      
      msgLines.push(
        '',
        '🎯 可用功能：',
        '• #签到 - 立即签到',
        '• #签到状态 - 查看签到状态',
        '• #开启自动签到 - 开启自动签到',
        '',
        '💡 更多帮助：#签到帮助'
      )
      
      await this.reply(msgLines.join('\n'), true)
      
      logger.info(`[签到插件] Cookie同步成功: QQ=${qq}, UID=${yunzaiCookie.uid}`)
      
    } catch (error) {
      logger.error('[签到插件] 同步Cookie失败:', error)
      await this.reply([
        '❌ 同步失败',
        '',
        `错误信息：${error.message}`,
        '',
        '💡 请稍后重试或查看控制台日志'
      ].join('\n'), true)
    }
    
    return true
  }

  /**
   * 原神自动签到定时任务
   */
  async autoSignTaskGS() {
    if (!Config.get('autoSign.enable', true)) {
      logger.info('[签到插件] 自动签到功能未开启')
      return
    }

    const result = await signService.autoSignTaskByGame('gs')
    logger.info(`[签到插件] 原神自动签到完成: 成功${result.success}个, 失败${result.failed}个`)

    // 推送结果
    if (Config.get('autoSign.push', true) && result.total > 0) {
      await this.pushSignResultSingle(result)
    }
  }

  /**
   * 星铁自动签到定时任务
   */
  async autoSignTaskSR() {
    if (!Config.get('autoSign.enable', true)) {
      logger.info('[签到插件] 自动签到功能未开启')
      return
    }

    const result = await signService.autoSignTaskByGame('sr')
    logger.info(`[签到插件] 星铁自动签到完成: 成功${result.success}个, 失败${result.failed}个`)

    // 推送结果
    if (Config.get('autoSign.push', true) && result.total > 0) {
      await this.pushSignResultSingle(result)
    }
  }

  /**
   * 推送单个游戏的签到结果
   */
  async pushSignResultSingle(result) {
    try {
      // 获取Bot实例（尝试多种方式）
      let BotInstance = null
      if (typeof Bot !== 'undefined') {
        BotInstance = Bot
      } else if (global.Bot) {
        BotInstance = global.Bot
      }
      
      if (BotInstance) {
        await signService.pushSignResult(result, BotInstance)
      } else {
        logger.warn('[签到插件] 无法获取Bot实例，跳过推送')
      }
    } catch (error) {
      logger.error('[签到插件] 推送签到结果失败:', error)
    }
  }

  /**
   * 自动签到定时任务（兼容旧版，已废弃）
   */
  async autoSignTask() {
    if (!Config.get('autoSign.enable', true)) {
      logger.info('[签到插件] 自动签到功能未开启')
      return
    }

    const result = await signService.autoSignTask()
    logger.info(`[签到插件] 自动签到完成: 成功${result.success}个, 失败${result.failed}个`)

    // 推送结果
    if (Config.get('autoSign.push', true) && result.total > 0) {
      try {
        // 获取Bot实例（尝试多种方式）
        let BotInstance = null
        if (typeof Bot !== 'undefined') {
          BotInstance = Bot
        } else if (global.Bot) {
          BotInstance = global.Bot
        }
        
        if (BotInstance) {
          await signService.pushSignResult(result, BotInstance)
        } else {
          logger.warn('[签到插件] 无法获取Bot实例，跳过推送')
        }
      } catch (error) {
        logger.error('[签到插件] 推送签到结果失败:', error)
      }
    }
  }

  /**
   * 解析Cron表达式为可读文本
   */
  parseCron(cron) {
    const parts = cron.split(' ')
    if (parts.length >= 6) {
      const hour = parts[2]
      const minute = parts[1]
      return `每天 ${hour}:${minute.padStart(2, '0')}`
    }
    return cron
  }

  /**
   * 查看插件版本
   */
  async pluginVersion(e) {
    const __filename = fileURLToPath(import.meta.url)
    const __dirname = path.dirname(__filename)
    const pluginPath = path.resolve(__dirname, '..')

    try {
      // 动态读取 package.json（避免缓存）
      const fs = await import('fs')
      const packagePath = path.join(pluginPath, 'package.json')
      const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
      const currentVersion = packageData.version

      // 获取当前分支和最新提交
      const { stdout: branch } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: pluginPath })
      const { stdout: commit } = await execAsync('git rev-parse --short HEAD', { cwd: pluginPath })
      const { stdout: commitDate } = await execAsync('git log -1 --format=%cd --date=format:"%Y-%m-%d %H:%M:%S"', { cwd: pluginPath })

      const msg = [
        '📦 米游社签到插件',
        '',
        `版本：v${currentVersion}`,
        `分支：${branch.trim()}`,
        `提交：${commit.trim()}`,
        `更新时间：${commitDate.trim()}`,
        '',
        '🔄 更新命令：#更新签到插件',
        '📖 帮助命令：#签到帮助',
        '',
        '仓库地址：',
        'https://gitee.com/yyshui/sys-sign-plugin'
      ].join('\n')

      await this.reply(msg, true)
    } catch (error) {
      logger.error('[签到插件] 获取版本信息失败:', error)
      await this.reply(`当前版本：v${version}\n更新命令：#更新签到插件`, true)
    }

    return true
  }

  /**
   * 更新插件
   */
  async updatePlugin(e) {
    if (!e.isMaster) {
      await this.reply('❌ 仅主人可以更新插件', true)
      return true
    }

    const __filename = fileURLToPath(import.meta.url)
    const __dirname = path.dirname(__filename)
    const pluginPath = path.resolve(__dirname, '..')

    await this.reply('⏳ 正在检查更新...', true)

    try {
      // 检查是否是 Git 仓库
      await execAsync('git rev-parse --git-dir', { cwd: pluginPath })
    } catch (error) {
      await this.reply('❌ 当前插件不是通过 Git 安装的，无法自动更新\n请手动下载最新版本', true)
      return true
    }

    try {
      // 获取当前提交
      const { stdout: oldCommit } = await execAsync('git rev-parse --short HEAD', { cwd: pluginPath })

      // 检查远程更新
      await execAsync('git fetch origin', { cwd: pluginPath })

      // 获取远程最新提交
      const { stdout: remoteCommit } = await execAsync('git rev-parse --short origin/master', { cwd: pluginPath })

      // 比较本地和远程
      if (oldCommit.trim() === remoteCommit.trim()) {
        // 动态读取 package.json
        const fs = await import('fs')
        const packagePath = path.join(pluginPath, 'package.json')
        const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
        const currentVersion = packageData.version

        await this.reply([
          '✅ 插件已是最新版本',
          '',
          `当前版本：v${currentVersion}`,
          `提交：${oldCommit.trim()}`,
          '',
          '💡 查看版本信息：#签到插件版本'
        ].join('\n'), true)
        return true
      }

      // 执行更新
      await this.reply('🔄 发现新版本，正在更新...', true)

      // 保存本地修改（如果有）
      try {
        await execAsync('git stash', { cwd: pluginPath })
      } catch (error) {
        // 忽略 stash 错误
      }

      // 拉取最新代码
      const { stdout: pullOutput } = await execAsync('git pull origin master', { cwd: pluginPath })

      // 恢复本地修改
      try {
        await execAsync('git stash pop', { cwd: pluginPath })
      } catch (error) {
        // 忽略 stash pop 错误
      }

      // 安装依赖
      await this.reply('📦 正在安装依赖...', true)
      try {
        await execAsync('pnpm install --production', { cwd: pluginPath })
      } catch (error) {
        // 如果 pnpm 失败，尝试 npm
        try {
          await execAsync('npm install --production', { cwd: pluginPath })
        } catch (error2) {
          logger.warn('[签到插件] 依赖安装失败，可能需要手动执行 pnpm install')
        }
      }

      // 获取更新后的提交
      const { stdout: newCommit } = await execAsync('git rev-parse --short HEAD', { cwd: pluginPath })

      // 动态读取更新后的版本号
      const fs = await import('fs')
      const packagePath = path.join(pluginPath, 'package.json')
      const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
      const newVersion = packageData.version

      // 获取更新日志
      let updateLog = ''
      try {
        const { stdout: log } = await execAsync(
          `git log ${oldCommit.trim()}..${newCommit.trim()} --pretty=format:"• %s" --max-count=10`,
          { cwd: pluginPath }
        )
        updateLog = log.trim()
      } catch (error) {
        updateLog = '无法获取更新日志'
      }

      const msg = [
        '✅ 插件更新成功！',
        '',
        `新版本：v${newVersion}`,
        `提交：${newCommit.trim()}`,
        '',
        '📝 更新内容：',
        updateLog || '• 优化和修复',
        '',
        '⚠️ 请重启 Yunzai 使更新生效',
        '重启命令：#重启'
      ].join('\n')

      await this.reply(msg, true)
    } catch (error) {
      logger.error('[签到插件] 更新失败:', error)
      
      let errorMsg = '❌ 更新失败：'
      if (error.message.includes('CONFLICT')) {
        errorMsg += '\n存在冲突，请手动解决或删除插件重新安装'
      } else if (error.message.includes('timeout')) {
        errorMsg += '\n网络超时，请检查网络连接或稍后重试'
      } else {
        errorMsg += '\n' + error.message
      }

      errorMsg += '\n\n💡 手动更新方法：'
      errorMsg += '\ncd plugins/mys-sign-plugin'
      errorMsg += '\ngit pull'
      errorMsg += '\npnpm install'

      await this.reply(errorMsg, true)
    }

    return true
  }
}
